#include <bits/stdc++.h>
using namespace std;
using ll = long long;

// 定义线段结构体，用于存储移动方向和步数
struct seg {
    char dir;   // 移动方向：U(上)、D(下)、L(左)、R(右)
    ll count;   // 移动步数
};

int main() {
    // 读取初始位置和目标位置
    ll Rt, Ct, Ra, Ca;
    cin >> Rt >> Ct >> Ra >> Ca;
    
    // 读取移动段数和其他参数
    ll n;
    int m, L;
    cin >> n >> m >> L;
    
    // 存储两个对象的移动序列
    vector<seg> segsS(m);
    vector<seg> segsT(L);
    
    // 读取两个对象的移动序列
    for (int i = 0; i < m; i++) cin >> segsS[i].dir >> segsS[i].count;
    for (int i = 0; i < L; i++) cin >> segsT[i].dir >> segsT[i].count;
    
    // 计算初始位置差值
    ll dx = Rt - Ra;  // 行差
    ll dy = Ct - Ca;  // 列差
    
    // 记录相遇次数
    ll ans = 0;
    
    // 双指针遍历两个移动序列
    int is = 0, it = 0;
    ll rs = segsS[is].count;  // 当前S剩余步数
    ll rt = segsT[it].count;  // 当前T剩余步数
    
    // 遍历两个移动序列，直到其中一个结束
    while (is < m && it < L) {
        // 取两个当前段的最小步数作为本次计算的长度
        ll len = min(rs, rt);
        
        // 获取当前段的移动方向
        char sd = segsS[is].dir;
        char td = segsT[it].dir;
        
        // 计算相对移动方向
        ll ddx = 0, ddy = 0;
        
        // 计算S的移动分量
        if (sd == 'U') ddx -= 1;
        else if (sd == 'D') ddx += 1;
        else if (sd == 'L') ddy -= 1;
        else if (sd == 'R') ddy += 1;

        // 计算T的移动分量（注意是相对移动）
        if (td == 'U') ddx += 1;
        if (td == 'D') ddx -= 1;
        else if (td == 'L') ddy += 1;
        else if (td == 'R') ddy -= 1;
        
        // 根据相对移动方向判断是否相遇
        if (ddx == 0 && ddy == 0) {  // 方向完全一致
            if (dx == 0 && dy == 0) {  // 初始位置相同，则一直相遇，反之不遇
                ans += len;
            }
        } else if (ddx == 0 && ddy != 0) {  // 列移动方向不同
            if (dx == 0) {  // 行相同则可能相遇
                if (dy % ddy == 0) {  // 能整除则能相遇
                    ll i = -dy / ddy;
                    if (i >= 1 && i <= len) {
                        ans++;
                    }
                }
            }
        } else if (ddy == 0 && ddx != 0) {  // 行移动方向不同
            if (dy == 0) {  // 列相同则可能相遇
                if (dx % ddx == 0) {  // 能整除则能相遇
                    ll i = -dx / ddx;
                    if (i >= 1 && i <= len) {
                        ans++;
                    }
                }
            }
        } else {  // 一般情况
            if (dx * ddy == dy * ddx) {  // dx/ddx = dy/ddy，即在同一条直线上
                if (dx % ddx == 0) {
                    ll i = -dx / ddx;
                    if (i >= 1 && i <= len) {
                        ans++;
                    }
                }
            }
        }
        
        // 更新位置差值
        dx += len * ddx;
        dy += len * ddy;
        
        // 更新剩余步数
        rs -= len;
        rt -= len;
        
        // 如果当前段结束，移动到下一段
        if (rs == 0) {
            is++;
            if (is < m) {
                rs = segsS[is].count;
            }
        }
        if (rt == 0) {
            it++;
            if (it < L) {
                rt = segsT[it].count;
            }
        }
    }
    
    // 输出相遇次数
    cout << ans << endl;
    
    return 0;
}